home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / AptUrl / AptUrl.py next >
Text File  |  2009-09-18  |  9KB  |  248 lines
  1. # Copyright (c) 2007-2008 Canonical
  2. #
  3. # AUTHOR:
  4. # Michael Vogt <mvo@ubuntu.com>
  5. # With contributions by Siegfried-A. Gevatter <rainct@ubuntu.com>
  6. #
  7. # This file is part of AptUrl
  8. #
  9. # AptUrl is free software; you can redistribute it and/or
  10. # modify it under the terms of the GNU General Public License as published
  11. # by the Free Software Foundation; either version 2 of the License, or (at
  12. # your option) any later version.
  13. #
  14. # AptUrl is distributed in the hope that it will be useful,
  15. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17. # General Public License for more details.
  18. #
  19. # You should have received a copy of the GNU General Public License
  20. # along with AptUrl; if not, write to the Free Software
  21. # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22.  
  23. import sys
  24. import apt
  25. import apt_pkg
  26. import gettext
  27.  
  28. import aptsources.distro
  29. import Parser
  30. import Helpers
  31. from Helpers import utf8, _, _n
  32.  
  33. from aptsources.sourceslist import SourcesList, is_mirror
  34. from optparse import OptionParser
  35.  
  36. import os
  37. import os.path
  38.  
  39. # adding new repositories is currently disabled because some people have
  40. # security concerns about this feature
  41. allow_new_repositories = False
  42.  
  43. # channels that we know about
  44. channelsdir = "/usr/share/app-install/channels"
  45.  
  46. # return codes
  47. (RESULT_OK,
  48.  RESULT_CANCELT,
  49.  RESULT_ERROR,
  50.  RESULT_BADARGS) = range(4)
  51.  
  52. class AptUrlController(object):
  53.  
  54.     def __init__(self, ui):
  55.         self.ui = ui
  56.  
  57.     def enableSection(self, apturl):
  58.         added = False
  59.  
  60.         # parse sources.list
  61.         sourceslist = SourcesList()
  62.         distro = aptsources.distro.get_distro()
  63.         distro.get_sources(sourceslist)
  64.  
  65.         # check if we actually need to enable anything
  66.         requested_components = []
  67.         for component in apturl.section:
  68.             if not component in distro.enabled_comps:
  69.                 requested_components.append(component)
  70.         # if not, we are fine
  71.         if not requested_components:
  72.             return RESULT_OK
  73.         # otherwise ask the user if the really wants to anble them
  74.         if not self.ui.askEnableSections(apturl.section):
  75.             return RESULT_CANCELT
  76.         if not self.ui.doEnableSection(apturl.section):
  77.             self.ui.error(_("Enabling '%s' failed") % ", ".join(apturl.section))
  78.             return RESULT_ERROR
  79.         self.ui.doUpdate()
  80.         self.openCache()
  81.         return RESULT_OK
  82.  
  83.     def enableChannel(self, apturl):
  84.         # ensure that no funny path tricks can be played
  85.         # by e.g. passing "apt:foo?channel=../../"
  86.         channel = os.path.basename(apturl.channel)
  87.  
  88.         channelpath = "%s/%s.list" % (channelsdir,channel)
  89.         channelkey = "%s/%s.key" % (channelsdir,channel)
  90.         channelhtml = "%s/%s.eula" % (channelsdir,channel)
  91.  
  92.         # check
  93.         if not os.path.exists(channelpath):
  94.             self.ui.error(_("Unknown channel '%s'") % channel,
  95.                           _("The channel '%s' is not known") % channel)
  96.             return RESULT_ERROR
  97.         channel_info_html = ""
  98.         if os.path.exists(channelhtml):
  99.             channel_info_html = open(channelhtml).read()
  100.         if not self.ui.askEnableChannel(apturl.channel, channel_info_html):
  101.             return RESULT_CANCELT
  102.         if not self.ui.doEnableChannel(channelpath, channelkey):
  103.             self.ui.error(_("Enabling channel '%s' failed") % apturl.channel)
  104.             return RESULT_ERROR
  105.         self.ui.doUpdate()
  106.         self.openCache()
  107.         return RESULT_OK
  108.  
  109.     def openCache(self):
  110.         try:
  111.             self.cache = apt.Cache()
  112.         except SystemError, strerr:
  113.             if not '/etc/apt/sources.list' in str(strerr):
  114.                 raise
  115.             self.ui.error(_("Invalid /etc/apt/sources.list file"), strerr)
  116.             return False
  117.         if self.cache._depcache.BrokenCount > 0:
  118.             err_header = _("Software index is broken")
  119.             err_body = _("This is a major failure of your software " 
  120.                          "management system. Please check for broken packages "
  121.                          "with synaptic, check the file permissions and "
  122.                          "correctness of the file '/etc/apt/sources.list' and "
  123.                          "reload the software information with: "
  124.                          "'sudo apt-get update' and 'sudo apt-get install -f'."
  125.                          )
  126.             self.ui.error(err_header, err_body)
  127.             return False
  128.         return True
  129.     
  130.     def parseArgs(self):
  131.         parser = OptionParser()
  132.         parser.add_option("-p", "--http-proxy", dest="http_proxy",
  133.                           default=None, help="use http proxy")
  134.         (options, args) = parser.parse_args()
  135.  
  136.         # eval and add proxy
  137.         if options.http_proxy is not None:
  138.             proxy = options.http_proxy
  139.             if not ":" in proxy:
  140.                 proxy += ":3128"
  141.             os.environ["http_proxy"] = "http://%s" % proxy
  142.  
  143.         # parse
  144.         try:
  145.             apturl_list = Parser.parse(args[0])
  146.         except IndexError, e:
  147.             self.ui.error(_("Need a url to continue, exiting"))
  148.             return []
  149.         except Parser.InvalidUrlException, e:
  150.             self.ui.error(_("Invalid url: '%s' given, exiting") % sys.argv[1],
  151.                           "%s" % e)
  152.             return []
  153.         return (apturl_list)
  154.         
  155.     def verifyInstall(self, apturl):
  156.         " verify that the install package actually is installed "
  157.         # check if the package got actually installed
  158.         self.openCache()
  159.         pkg = self.cache[apturl.package]
  160.         if (not pkg.isInstalled or
  161.             pkg._pkg.CurrentState != apt_pkg.CurStateInstalled or
  162.             self.cache._depcache.BrokenCount > 0):
  163.             return False
  164.         return True
  165.  
  166.     def main(self):
  167.         # global return code
  168.         ret = RESULT_OK
  169.         ui = self.ui
  170.         
  171.         # parse arguments
  172.         apturl_list = self.parseArgs()
  173.         if not apturl_list:
  174.             return RESULT_BADARGS
  175.         
  176.         # open cache
  177.         if not self.openCache():
  178.             return RESULT_ERROR
  179.  
  180.         # now go over the url list
  181.         for apturl in apturl_list:
  182.             # FIXME: move this code block into a func like
  183.             #        evalAptUrl()
  184.  
  185.             if not apturl.schema in ("apt", "apt+http"):
  186.                 self.ui.error(_("Can not deal with protocol '%s' ") % apturl.schema)
  187.                 continue
  188.  
  189.             if apturl.section:
  190.                 if self.enableSection(apturl) != RESULT_OK:
  191.                     continue
  192.             elif apturl.channel:
  193.                 if self.enableChannel(apturl) != RESULT_OK:
  194.                     continue
  195.             elif apturl.refresh is not None:
  196.                 ui.doUpdate()
  197.                 if not self.openCache():
  198.                     return RESULT_ERROR
  199.             
  200.             # now check the package
  201.             if not self.cache.has_key(apturl.package):
  202.                 try:
  203.                     package_in_cache = bool(self.cache._cache[apturl.package])
  204.                 except KeyError:
  205.                     package_in_cache = False
  206.                 if package_in_cache:
  207.                     ui.error(_("Package '%s' is virtual.") % apturl.package)
  208.                     continue
  209.                 else:
  210.                     ui.error(_("Could not find package '%s'.") % apturl.package)
  211.                     continue
  212.             
  213.             if self.cache[apturl.package].isInstalled and apturl.minver is None:
  214.                 ui.message(_("Package '%s' is already installed") % apturl.package)
  215.                 continue
  216.  
  217.             # ask the user
  218.             pkg = self.cache[apturl.package]
  219.             (sum, desc, homepage) = Helpers.parse_pkg(pkg)
  220.             if not ui.askInstallPackage(apturl.package, sum, desc, homepage):
  221.                 ret = RESULT_CANCELT
  222.                 continue
  223.             
  224.             # try to install it
  225.             try:
  226.                 self.cache[apturl.package].markInstall()
  227.             except SystemError, e:
  228.                 ui.error(_("Can not install '%s' (%s) ") % (apturl.package, e))
  229.                 continue
  230.             if apturl.minver is not None:
  231.                 verStr = self.cache[apturl.package].candidateVersion
  232.                 if apt_pkg.VersionCompare(verStr, apturl.minver) < 1:
  233.                     ui.error(_("Package '%s' requests minimal version '%s', but "
  234.                                "only '%s' is available") % (apturl.package,
  235.                                                             apturl.minver,
  236.                                                             verStr))
  237.                     continue
  238.  
  239.             # install it
  240.             ui.doInstall(apturl)
  241.  
  242.             if not self.verifyInstall(apturl):
  243.                 ret = RESULT_ERROR
  244.  
  245.         # return values
  246.         return ret
  247.             
  248.